package Correo;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;
import org.apache.struts.action.Action;

/**
 *
 * @author Antonio
 */
public class CorreoSaliente extends Action {

    /**
     * Parsea las direcciones de correo desde una cadena con las direcciones separadas por comas.
     * @param addresses Cadena con las direcciones de correo
     * @return Vector con las direcciones parseadas.
     */
    static Vector parseAddresses(String sAddresses) {
        Vector vector = new Vector();
        if (sAddresses != null) {
            StringTokenizer st = new StringTokenizer(sAddresses, ",");
            while (st.hasMoreTokens()) {
                vector.add(st.nextToken());
            }
        }
        return vector;
    }

    /**
     * Parsea los attachments desde una cadena con los attachments separados por comas.
     * @param attachments Cadena con los attachments de correo
     * @return Vector con los attachments parseados.
     */
    static Vector parseAttachments(String sAttachments) {
        return parseAddresses(sAttachments);
    }

    /**
     * Envia un correo por SMTP.
     * @param sFromAddress Dirección del remitente.
     * @param sToAddress Cadena con los destinatarios separados por comas.
     * @param sSubject Asunto del correo.
     * @param sBody Texto del correo.
     * @param sBodyHTML Correo en html.
     * @param sFileAttachments Cadena con los attachments separados por comas..
     */
    protected static void send(String sFromAddress, String sToAddresses,
            String sSubject, String sBody, String sBodyHTML, String sFileAttachments)
            throws AddressException,SendFailedException, MessagingException {
// Set this variable to be your SMTP host
        String mailHost = "smtp.gmail.com";
        String sFrom = sFromAddress;
        Vector vTo = parseAddresses(sToAddresses);
        Vector vAttachments = parseAttachments(sFileAttachments);


//Get system properties
        Properties props = System.getProperties();
        props.setProperty("mail.smtp.user", "proyectofamilytree@gmail.com");
        // TLS si está disponible
        props.setProperty("mail.smtp.starttls.enable", "true");

// Puerto de gmail para envio de correos
        props.setProperty("mail.smtp.port", "25");


// Si requiere o no usuario y password para conectarse.
        props.setProperty("mail.smtp.auth", "true");
        props.setProperty("mail.smpt.password", "123qweasd");

//Specify the desired SMTP server
        props.setProperty("mail.smtp.host", mailHost);

// create a new Session object
        Session sesion = Session.getInstance(props, null);
//sesion.setDebug(true);
        
        Transport t = sesion.getTransport("smtp");
        t.connect("proyectofamilytree@gmail.com","123qweasd");

// create a new MimeMessage object (using the Session created above)
        Message message = new MimeMessage(sesion);

// Message add FROM
        message.setFrom(new InternetAddress(sFrom));

// Message add TO
//message.setRecipients(Message.RecipientType.TO, new InternetAddress[] { new InternetAddress(sTo) });
        for (Enumeration eToAddresses = vTo.elements(); eToAddresses.hasMoreElements();) {
            message.addRecipient(Message.RecipientType.TO, new InternetAddress((String) eToAddresses.nextElement()));
        }
// Message add Subject
        message.setSubject(sSubject);

        if (vAttachments.size() == 0) { // No Multi-part mail

            message.setText(sBody);
        } else {
//Necesitamos crear el objeto Multipart:
//Multipart multipart = new MimeMultipart();
            Multipart multipart = new MimeMultipart((sBodyHTML == null || sBodyHTML.length() == 0) ? "mixed" : "related");

// Para la parte uno, creamos un BodyPart y seleccionamos el texto para
// ser un mensaje. Luego añadimos el BodyPart al Multipart recién creado.
            BodyPart messageBodyPart = new MimeBodyPart();
            messageBodyPart.setText(sBody + "\n");
            multipart.addBodyPart(messageBodyPart);

// Create part text, Fill sBodyHTML and add the part
            if (sBodyHTML != null) {//|| sBodyHTML.length() > 0) {

                BodyPart messageHtmlTextPart = new MimeBodyPart();
                messageHtmlTextPart.setDataHandler(new DataHandler(new SMTPByteArrayDataSource(sBodyHTML, "text/html")));
                multipart.addBodyPart(messageHtmlTextPart);
            }

// Create part attachments, Fill attachments and add the part
            for (Enumeration eAttachments = vAttachments.elements(); eAttachments.hasMoreElements();) {
                String nameFile = (String) eAttachments.nextElement();
// Para la parte dos, necesitamos crear otro BodyPart, pero esta vez,
// necesitamos crear un DataSource para el fichero:
                BodyPart messageAttachmentsPart = new MimeBodyPart();
                DataSource source = new FileDataSource(nameFile);
// Usamos un objeto DataHandler para adjuntar los datos al mensaje.
// Simplemente creamos un DataHandler para la fuente y lo adjuntamos al
// mensaje:
                messageAttachmentsPart.setDataHandler(new DataHandler(source));
// Debemos recordar seleccionar el nombre de fichero para el attachment.
// Esto permite al receptor conocer el nombre (y el tipo) del fichero
// recibido.
//messageAttachmentsPart.setHeader( "Content-ID", nameFile);

//messageAttachmentsPart.setFileName( ( new File( nameFile)).getName());
                StringTokenizer ftokenizer = new StringTokenizer(nameFile, "\\/:");
                String filename = ftokenizer.nextToken();
                while (ftokenizer.hasMoreTokens()) {
                    filename = ftokenizer.nextToken();
                }
                messageAttachmentsPart.setFileName(filename);

//Adjuntamos la parte dos de la misma forma que la parte uno:
                multipart.addBodyPart(messageAttachmentsPart);
            }
// Para la parte dos, necesitamos crear otro BodyPart, pero esta vez,
// necesitamos crear un DataSource para el fichero:
//messageBodyPart = new MimeBodyPart();
//DataSource source = new FileDataSource(sFileAttachments);

// Usamos un objeto DataHandler para adjuntar los datos al mensaje.
// Simplemente creamos un DataHandler para la fuente y lo adjuntamos al
// mensaje:
//messageBodyPart.setDataHandler(new DataHandler(source));

// Debemos recordar seleccionar el nombre de fichero para el attachment.
// Esto permite al receptor conocer el nombre (y el tipo) del fichero
// recibido.
//messageBodyPart.setFileName(sAttachFile);
//messageBodyPart.setFileName("kk.txt");

//Adjuntamos la parte dos de la misma forma que la parte uno:
//multipart.addBodyPart(messageBodyPart);

// Y como paso final, antes de enviarlo, adjutamos el Multipart al Message:
            message.setContent(multipart);
        }
        
        
        t.sendMessage(message,message.getAllRecipients());
        
// it worked!
    }

    /**
     * Envia un correo por SMTP.
     * @param host Dirección del host SMTP.
     * @param sFromAddress Dirección del remitente.
     * @param sToAddress Cadena con los destinatarios separados por comas.
     * @param sSubject Asunto del correo.
     * @param sBody Texto del correo.
     */
    public static void sendMail(String sFromAddress,
            String sToAddresses, String sSubject, String sBody) throws
            AddressException, SendFailedException, MessagingException {
        send(sFromAddress, sToAddresses, sSubject, sBody, null, null);
    }

    
    /**
     * Envia un correo por SMTP.
     * @param sFromAddress Dirección del remitente.
     * @param sToAddress Cadena con los destinatarios separados por comas.
     * @param sSubject Asunto del correo.
     * @param sBody Texto del correo.
     * @param sBodyHTML Correo en html.
     * @param sFileAttachments Cadena con los attachments separados por comas..
     */
    public static void sendMail(String sFromAddress,
            String sToAddresses, String sSubject, String sBody, String sBodyHTML, String sFileAttachments)
            throws AddressException,SendFailedException, MessagingException {
        send(sFromAddress, sToAddresses, sSubject, sBody, sBodyHTML, sFileAttachments);
    }
    
    
    /**
     * Envia un correo por SMTP.
     * @param sToAddress Cadena con los destinatarios separados por comas.
     * @param sSubject Asunto del correo.
     * @param sBody Texto del correo.
     * @param sBodyHTML Correo en html.
     * @param sFileAttachments Cadena con los attachments separados por comas..
     */ 
   public static void sendMail(String sToAddresses, String sSubject, String sBody, 
           String sBodyHTML, String sFileAttachments)
            throws AddressException,SendFailedException, MessagingException {
        send("proyectofamilytree@gmail.com", sToAddresses, sSubject, sBody, sBodyHTML, sFileAttachments);
    }
}
